package com.digitalbuana.smiles.data.extension.archive;

import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.IQ.Type;
import org.jivesoftware.smack.packet.Packet;

import com.digitalbuana.smiles.R;
import com.digitalbuana.smiles.data.Application;
import com.digitalbuana.smiles.data.NetworkException;
import com.digitalbuana.smiles.data.OnLoadListener;
import com.digitalbuana.smiles.data.account.AccountItem;
import com.digitalbuana.smiles.data.account.AccountManager;
import com.digitalbuana.smiles.data.account.ArchiveMode;
import com.digitalbuana.smiles.data.account.OnAccountAddedListener;
import com.digitalbuana.smiles.data.account.OnAccountArchiveModeChangedListener;
import com.digitalbuana.smiles.data.account.OnAccountRemovedListener;
import com.digitalbuana.smiles.data.connection.ConnectionItem;
import com.digitalbuana.smiles.data.connection.ConnectionManager;
import com.digitalbuana.smiles.data.connection.OnDisconnectListener;
import com.digitalbuana.smiles.data.connection.OnPacketListener;
import com.digitalbuana.smiles.data.connection.OnResponseListener;
import com.digitalbuana.smiles.data.entity.NestedMap;
import com.digitalbuana.smiles.data.entity.NestedNestedMaps;
import com.digitalbuana.smiles.data.extension.capability.ServerInfoManager;
import com.digitalbuana.smiles.data.extension.time.OnTimeReceivedListener;
import com.digitalbuana.smiles.data.extension.time.TimeManager;
import com.digitalbuana.smiles.data.message.AbstractChat;
import com.digitalbuana.smiles.data.message.MessageItem;
import com.digitalbuana.smiles.data.message.MessageManager;
import com.digitalbuana.smiles.data.notification.BaseAccountNotificationProvider;
import com.digitalbuana.smiles.data.notification.NotificationManager;
import com.digitalbuana.smiles.xmpp.address.Jid;
import com.digitalbuana.smiles.xmpp.archive.AbstractMessage;
import com.digitalbuana.smiles.xmpp.archive.Auto;
import com.digitalbuana.smiles.xmpp.archive.Chat;
import com.digitalbuana.smiles.xmpp.archive.CollectionHeader;
import com.digitalbuana.smiles.xmpp.archive.Default;
import com.digitalbuana.smiles.xmpp.archive.Item;
import com.digitalbuana.smiles.xmpp.archive.ItemRemove;
import com.digitalbuana.smiles.xmpp.archive.List;
import com.digitalbuana.smiles.xmpp.archive.Modified;
import com.digitalbuana.smiles.xmpp.archive.OtrMode;
import com.digitalbuana.smiles.xmpp.archive.Pref;
import com.digitalbuana.smiles.xmpp.archive.Retrieve;
import com.digitalbuana.smiles.xmpp.archive.SaveMode;
import com.digitalbuana.smiles.xmpp.archive.Session;
import com.digitalbuana.smiles.xmpp.archive.SessionRemove;
import com.digitalbuana.smiles.xmpp.rsm.Set;

public class MessageArchiveManager implements OnPacketListener,
		OnTimeReceivedListener, OnAccountAddedListener,
		OnAccountRemovedListener, OnLoadListener,
		OnAccountArchiveModeChangedListener, OnDisconnectListener {

	private static final Integer SESSION_TIMEOUT = 7 * 24 * 60 * 60;

	private static final int RSM_MAX = 20;

	private static final String FEATURE_ARCH = "urn:xmpp:archive";
	private static final String FEATURE_PREF = "urn:xmpp:archive:pref";
	private static final String FEATURE_MANAGE = "urn:xmpp:archive:manage";

	private final Map<String, Boolean> saves;

	private final Map<String, ArchivePreference> defaults;

	private final Map<String, Map<MatchMode, Map<String, ArchivePreference>>> items;

	private final NestedMap<SaveMode> sessionSaves;

	private final NestedMap<Boolean> modificationRequests;

	private final Map<String, ModificationStorage> modificationStorages;

	private final Map<String, Date> connected;

	private final NestedMap<HistoryStorage> historyStorages;

	private final NestedNestedMaps<String, ChatStorage> chatStorages;

	private final BaseAccountNotificationProvider<AvailableArchiveRequest> availableArchiveRequestProvider;

	private final static MessageArchiveManager instance;

	static {
		instance = new MessageArchiveManager(Application.getInstance());
		Application.getInstance().addManager(instance);
	}

	public static MessageArchiveManager getInstance() {
		return instance;
	}

	private MessageArchiveManager(Application application) {
		saves = new HashMap<String, Boolean>();
		defaults = new HashMap<String, ArchivePreference>();
		items = new HashMap<String, Map<MatchMode, Map<String, ArchivePreference>>>();
		sessionSaves = new NestedMap<SaveMode>();
		modificationStorages = new HashMap<String, ModificationStorage>();
		connected = new HashMap<String, Date>();
		historyStorages = new NestedMap<HistoryStorage>();
		modificationRequests = new NestedMap<Boolean>();
		chatStorages = new NestedNestedMaps<String, ChatStorage>();
		availableArchiveRequestProvider = new BaseAccountNotificationProvider<AvailableArchiveRequest>(
				R.drawable.ic_stat_request);
	}

	@Override
	public void onLoad() {
		Application.getInstance().runOnUiThread(new Runnable() {
			@Override
			public void run() {
				onLoaded();
			}
		});
	}

	private void onLoaded() {
		NotificationManager.getInstance().registerNotificationProvider(
				availableArchiveRequestProvider);
	}

	@Override
	public void onAccountAdded(AccountItem accountItem) {
		Map<MatchMode, Map<String, ArchivePreference>> maps = new HashMap<MatchMode, Map<String, ArchivePreference>>();
		for (MatchMode matchMode : MatchMode.values())
			maps.put(matchMode, new HashMap<String, ArchivePreference>());
		items.put(accountItem.getAccount(), maps);
	}

	@Override
	public void onAccountRemoved(AccountItem accountItem) {
		saves.remove(accountItem.getAccount());
		defaults.remove(accountItem.getAccount());
		items.remove(accountItem.getAccount());
		sessionSaves.clear(accountItem.getAccount());
		modificationStorages.remove(accountItem.getAccount());
		connected.remove(accountItem.getAccount());
		historyStorages.clear(accountItem.getAccount());
		chatStorages.clear(accountItem.getAccount());
	}

	@Override
	public void onDisconnect(ConnectionItem connection) {
		if (connection instanceof AccountItem)
			modificationRequests.clear(((AccountItem) connection).getAccount());
	}

	@Override
	public void onTimeReceived(final ConnectionItem connection) {
		if (!(connection instanceof AccountItem)) {
			onModifiedAvailable(connection);
			return;
		}
		String account = ((AccountItem) connection).getAccount();
		ModificationStorage modificationStorage = modificationStorages
				.get(account);
		if (modificationStorage == null) {
			modificationStorage = new ModificationStorage();
			modificationStorages.put(account, modificationStorage);
		}
		modificationStorage.onConnected();
		removeNotReceived(account);
		ArchiveMode archiveMode = AccountManager.getInstance().getArchiveMode(
				account);
		if (ServerInfoManager.getInstance().isProtocolSupported(account,
				FEATURE_ARCH)
				|| ServerInfoManager.getInstance().isProtocolSupported(account,
						FEATURE_PREF)
				|| ServerInfoManager.getInstance().isProtocolSupported(account,
						FEATURE_MANAGE)) {
			if (archiveMode == ArchiveMode.available) {
				availableArchiveRequestProvider.add(
						new AvailableArchiveRequest(account), null);
			}
		}
		if (archiveMode != ArchiveMode.server) {
			onModifiedAvailable(account);
			return;
		}
		if (ServerInfoManager.getInstance().isProtocolSupported(account,
				FEATURE_PREF)) {
			requestPreferences(account);
			return;
		}
		onPreferenceAvailable(account);
	}

	/**
	 * Removes chat storages that wasn't fully received.
	 * 
	 * @param account
	 */
	private void removeNotReceived(String account) {
		NestedNestedMaps<String, ChatStorage> remove = new NestedNestedMaps<String, ChatStorage>();
		for (Entry<String, Map<String, ChatStorage>> users : chatStorages
				.getNested(account).entrySet())
			for (Entry<String, ChatStorage> storages : users.getValue()
					.entrySet())
				if (!storages.getValue().isReceived())
					remove.put(account, users.getKey(), storages.getKey(),
							storages.getValue());
		for (Entry<String, Map<String, ChatStorage>> users : remove.getNested(
				account).entrySet())
			for (Entry<String, ChatStorage> storages : users.getValue()
					.entrySet())
				chatStorages.remove(account, users.getKey(), storages.getKey());
	}

	protected void onPreferenceAvailable(String account) {
		if (ServerInfoManager.getInstance().isProtocolSupported(account,
				FEATURE_MANAGE)) {
			ModificationStorage modificationStorage = modificationStorages
					.get(account);
			if (modificationStorage.request(TimeManager.getInstance()
					.getServerTime(account))) {
				requestModified(account, "");
				return;
			}
		}
		onModifiedAvailable(account);
	}

	private void onModifiedAvailable(String account) {
		modificationStorages.get(account).onFinished();
		removeNotReceived(account);
		connected
				.put(account, TimeManager.getInstance().getServerTime(account));
		onModifiedAvailable(AccountManager.getInstance().getAccount(account));
		if (AccountManager.getInstance().getArchiveMode(account) == ArchiveMode.server)
			for (Entry<String, HistoryStorage> entity : historyStorages
					.getNested(account).entrySet())
				if (entity.getValue().onResume())
					requestSequence(account, entity.getKey(), entity.getValue());
	}

	private void onModifiedAvailable(ConnectionItem connection) {
		for (OnArchiveModificationsReceivedListener listener : Application
				.getInstance().getManagers(
						OnArchiveModificationsReceivedListener.class))
			listener.onArchiveModificationsReceived(connection);
	}

	@Override
	public void onPacket(ConnectionItem connection, final String bareAddress,
			Packet packet) {
		if (!(connection instanceof AccountItem))
			return;
		String account = ((AccountItem) connection).getAccount();
		if (AccountManager.getInstance().getArchiveMode(account) != ArchiveMode.server)
			return;
		if (bareAddress != null && !Jid.getServer(account).equals(bareAddress))
			return;
		if (!(packet instanceof IQ))
			return;
		IQ iq = (IQ) packet;
		if (iq.getType() == Type.SET && packet instanceof Pref
				&& ((Pref) packet).isValid())
			onPreferenceReceived(account, (Pref) packet);
		else if (iq.getType() == Type.SET && packet instanceof ItemRemove
				&& ((ItemRemove) packet).isValid())
			onItemRemoveReceived(account, (ItemRemove) packet);
		else if (iq.getType() == Type.SET && packet instanceof SessionRemove
				&& ((SessionRemove) packet).isValid())
			onSessionRemoveReceived(account, (SessionRemove) packet);
		else if (iq.getType() == Type.RESULT && packet instanceof List
				&& ((List) packet).isValid())
			onListReceived(account, (List) packet);
		else if (iq.getType() == Type.RESULT && packet instanceof Chat
				&& ((Chat) packet).isValid())
			onChatReceived(account, (Chat) packet);
	}

	private void onPreferencesResponce(String account, Pref pref) {
		defaults.remove(account);
		for (Map<String, ArchivePreference> map : items.get(account).values())
			map.clear();
		sessionSaves.clear(account);
		checkForDefaults(account, pref.getDefault());
		Boolean autoSave = pref.getAutoSave();
		if (autoSave != null) {
			if (autoSave) {
				// TODO: check whether record can be disabled.
			} else if (AccountManager.getInstance().getArchiveMode(account) == ArchiveMode.server) {
				Auto auto = new Auto();
				auto.setSave(true);
				auto.setType(Type.SET);
				try {
					ConnectionManager.getInstance().sendPacket(account, auto);
				} catch (NetworkException e) {
				}
				// TODO: track results.
				saves.put(account, true);
			}
		}
		onPreferenceReceived(account, pref);
	}

	private void onPreferenceReceived(String account, Pref pref) {
		Default defaultItem = pref.getDefault();
		if (defaultItem != null)
			defaults.put(account, new ArchivePreference(defaultItem.getOtr(),
					defaultItem.getSave()));
		for (Item item : pref.getItems()) {
			MatchMode matchMode;
			String value = Jid.getStringPrep(item.getJid());
			if (item.getExactmatch() != null && item.getExactmatch()) {
				matchMode = MatchMode.exect;
			} else {
				String resource = Jid.getResource(item.getJid());
				if (resource != null && !"".equals(resource))
					matchMode = MatchMode.exect;
				else {
					String name = Jid.getName(item.getJid());
					if (name != null && !"".equals(name)) {
						matchMode = MatchMode.bare;
						value = Jid.getBareAddress(value);
					} else {
						matchMode = MatchMode.domain;
						value = Jid.getServer(value);
					}
				}
				items.get(account)
						.get(matchMode)
						.put(value,
								new ArchivePreference(item.getOtr(), item
										.getSave()));
			}
		}
		for (Session session : pref.getSessions())
			sessionSaves.put(account, session.getThread(), session.getSave());
	}

	private void checkForDefaults(String account, Default received) {
		if (received == null || !received.isUnset()
				|| received.getSave() != SaveMode.fls)
			return;
		Default defaultItem = new Default();
		defaultItem.setExpire(received.getExpire());
		defaultItem.setOtr(received.getOtr());
		defaultItem.setSave(SaveMode.body);
		Pref pref = new Pref();
		pref.setDefault(defaultItem);
		pref.setType(Type.SET);
		try {
			ConnectionManager.getInstance().sendPacket(account, pref);
		} catch (NetworkException e) {
		}
	}

	private void onItemRemoveReceived(String account, ItemRemove itemRemove) {
		for (Item item : itemRemove.getItems())
			for (Map<String, ArchivePreference> map : items.get(account)
					.values())
				map.remove(item.getJid());
	}

	private void onSessionRemoveReceived(String account,
			SessionRemove sessionRemove) {
		for (Session session : sessionRemove.getSessions())
			sessionSaves.remove(account, session.getThread());
	}

	private void onModifiedReceived(String account, Modified modified) {
		ModificationStorage modificationStorage = modificationStorages
				.get(account);
		onHeadersReceived(account, null, modificationStorage,
				modified.getChats(), modified.getRsm());
	}

	private void onListReceived(String account, List list) {
		String bareAddress = null;
		HistoryStorage historyStorage = null;
		for (Entry<String, HistoryStorage> entry : historyStorages.getNested(
				account).entrySet())
			if (entry.getValue().hasPacketId(list.getPacketID())) {
				bareAddress = entry.getKey();
				historyStorage = entry.getValue();
			}
		if (bareAddress == null)
			return;
		historyStorage.setPacketId(null);
		onHeadersReceived(account, bareAddress, historyStorage,
				list.getChats(), list.getRsm());
	}

	private void onHeadersReceived(String account, String bareAddress,
			HeaderSequence sequence,
			Collection<? extends CollectionHeader> headers, Set rsm) {
		sequence.addHeaders(headers);
		if (rsm == null || rsm.isBackwardFinished(headers.size()))
			sequence.onHeadersReceived();
		else
			sequence.setNext(rsm.getFirst());
		requestSequence(account, bareAddress, sequence);
	}

	private void onChatReceived(String account, Chat chat) {
		Boolean modification = modificationRequests.remove(account,
				chat.getPacketID());
		if (modification == null)
			return;
		ChatStorage chatStorage = chatStorages.get(account, chat.getWith(),
				chat.getStartString());
		String bareAddress = Jid.getBareAddress(chat.getWith());
		HeaderSequence sequence;
		if (modification)
			sequence = modificationStorages.get(account);
		else
			sequence = historyStorages.get(account, bareAddress);
		if (sequence == null)
			return;
		AbstractChat abstractChat = MessageManager.getInstance()
				.getOrCreateChat(account, bareAddress);
		for (AbstractMessage abstractMessage : chat.getMessages())
			chatStorage.addItem(abstractChat, chat, abstractMessage,
					TimeManager.getInstance().getServerTimeOffset(account));
		if (chat.getRsm() == null
				|| chat.getRsm().isForwardFinished(chat.getMessages().size())) {
			chatStorage.onItemsReceived(chat.getVersion());
			sequence.pollHeader();
			if (sequence instanceof HistoryStorage)
				if (apply(account, bareAddress, chat.getStartString(),
						chatStorage, (HistoryStorage) sequence))
					return;
			requestSequence(account, bareAddress, sequence);
		} else {
			requestChat(account, chat, chat.getRsm().getLast(), modification);
		}
	}

	/**
	 * Apply received messages.
	 * 
	 * @param account
	 * @param bareAddress
	 * @param tag
	 * @param chatStorage
	 * @param historyStorage
	 * @return Whether enough messages have been received.
	 */
	private boolean apply(String account, String bareAddress, String tag,
			ChatStorage chatStorage, HistoryStorage historyStorage) {
		AbstractChat abstractChat = MessageManager.getInstance().getChat(
				account, bareAddress);
		int newCount = abstractChat.onMessageDownloaded(tag,
				chatStorage.getItems(), false);
		int incomingCount = 0;
		for (MessageItem messageItem : chatStorage.getItems())
			if (messageItem.isIncoming())
				incomingCount += 1;
		chatStorage.onApplied();
		if (historyStorage.enoughMessages(newCount, incomingCount)) {
			historyStorage.onSuccess();
			return true;
		}
		return false;
	}

	/**
	 * Apply received messages.
	 * 
	 * @param account
	 * @param modificationStorage
	 */
	private void apply(String account, ModificationStorage modificationStorage) {
		for (Entry<String, Map<String, ChatStorage>> users : chatStorages
				.getNested(account).entrySet()) {
			String bareAddress = Jid.getBareAddress(users.getKey());
			AbstractChat abstractChat = MessageManager.getInstance().getChat(
					account, bareAddress);
			for (Entry<String, ChatStorage> storages : users.getValue()
					.entrySet()) {
				ChatStorage chatStorage = storages.getValue();
				if (chatStorage.isApplied())
					continue;
				abstractChat.onMessageDownloaded(storages.getKey(),
						chatStorage.getItems(), true);
				chatStorage.onApplied();
			}
		}
		modificationStorage.onSuccess();
	}

	private void requestPreferences(String account) {
		Pref pref = new Pref();
		pref.setType(Type.GET);
		try {
			ConnectionManager.getInstance().sendRequest(account, pref,
					new OnResponseListener() {

						@Override
						public void onReceived(String account, String packetId,
								IQ iq) {
							if (iq instanceof Pref && ((Pref) iq).isValid())
								onPreferencesResponce(account, (Pref) iq);
							onPreferenceAvailable(account);
						}

						@Override
						public void onError(String account, String packetId,
								IQ iq) {
							onPreferenceAvailable(account);
						}

						@Override
						public void onTimeout(String account, String packetId) {
							onError(account, packetId, null);
						}

						@Override
						public void onDisconnect(String account, String packetId) {
						}

					});
		} catch (NetworkException e) {
		}
	}

	private void requestSequence(String account, String bareAddress,
			HeaderSequence sequence) {
		while (true) {
			CollectionHeader header = sequence.peekHeader();
			if (header == null) {
				if (sequence.isHeadersReceived()) {
					if (sequence instanceof ModificationStorage) {
						apply(account, (ModificationStorage) sequence);
						onModifiedAvailable(account);
					}
				} else {
					if (sequence instanceof ModificationStorage) {
						requestModified(account, sequence.getNext());
					} else {
						((HistoryStorage) sequence).setPacketId(requestList(
								account, bareAddress, sequence.getNext()));
					}
				}
			} else {
				ChatStorage chatStorage = chatStorages.get(account,
						header.getWith(), header.getStartString());
				if (chatStorage == null
						|| (chatStorage.isReceived() && !chatStorage
								.hasVersion(header.getVersion()))) {
					chatStorage = new ChatStorage(header.getStart());
					chatStorages.put(account, header.getWith(),
							header.getStartString(), chatStorage);
				} else if (chatStorage.isReceived()) {
					if (sequence instanceof HistoryStorage
							&& !chatStorage.isApplied())
						if (apply(account, header.getWith(),
								header.getStartString(), chatStorage,
								(HistoryStorage) sequence))
							break;
					sequence.pollHeader();
					continue;
				}
				requestChat(account, header, null,
						sequence instanceof ModificationStorage);
			}
			break;
		}
	}

	private void requestModified(String account, String before) {
		Modified packet = new Modified();
		packet.setType(Type.GET);
		Set rsm = new Set();
		rsm.setMax(RSM_MAX);
		rsm.setBefore(before);
		packet.setRsm(rsm);
		packet.setStart(modificationStorages.get(account).getLastRequest());
		try {
			ConnectionManager.getInstance().sendRequest(account, packet,
					new OnResponseListener() {

						@Override
						public void onReceived(String account, String packetId,
								IQ iq) {
							if (iq instanceof Modified
									&& ((Modified) iq).isValid())
								onModifiedReceived(account, (Modified) iq);
							else
								onError(account, packetId, iq);
						}

						@Override
						public void onError(String account, String packetId,
								IQ iq) {
							onModifiedAvailable(account);
						}

						@Override
						public void onTimeout(String account, String packetId) {
							onError(account, packetId, null);
						}

						@Override
						public void onDisconnect(String account, String packetId) {
						}

					});
		} catch (NetworkException e) {
		}
	}

	/**
	 * At east <code>newCount</code> new messages and <code>incomingCount</code>
	 * incoming messages should be loaded from the server side history.
	 * 
	 * @param account
	 * @param bareAddress
	 * @param newCount
	 * @param incomingCount
	 */
	public void requestHistory(String account, String bareAddress,
			int newCount, int incomingCount) {
		if (AccountManager.getInstance().getArchiveMode(account) != ArchiveMode.server
				|| (newCount <= 0 && incomingCount <= 0))
			return;
		HistoryStorage historyStorage = historyStorages.get(account,
				bareAddress);
		if (historyStorage == null) {
			historyStorage = new HistoryStorage();
			historyStorages.put(account, bareAddress, historyStorage);
		}
		ModificationStorage modificationStorage = modificationStorages
				.get(account);
		if (historyStorage.isInProgress()
				|| (modificationStorage != null && modificationStorage
						.isInProgress())) {
			historyStorage.setRequestedCountAtLeast(newCount, incomingCount);
			return;
		}
		historyStorage.onRequest(newCount, incomingCount);
		requestSequence(account, bareAddress, historyStorage);
	}

	private String requestList(String account, String bareAddress, String before) {
		List packet = new List();
		packet.setType(Type.GET);
		Set rsm = new Set();
		rsm.setMax(RSM_MAX);
		rsm.setBefore(before);
		packet.setRsm(rsm);
		packet.setWith(bareAddress);
		packet.setEnd(connected.get(account));
		String packetId = packet.getPacketID();
		try {
			ConnectionManager.getInstance().sendPacket(account, packet);
		} catch (NetworkException e) {
		}
		return packetId;
	}

	private void requestChat(String account, CollectionHeader header,
			String after, boolean modification) {
		Retrieve packet = new Retrieve();
		packet.setType(Type.GET);
		Set rsm = new Set();
		rsm.setMax(RSM_MAX);
		rsm.setAfter(after);
		packet.setRsm(rsm);
		packet.setWith(header.getWith());
		packet.setStartString(header.getStartString());
		modificationRequests.put(account, packet.getPacketID(), modification);
		try {
			if (!modification) {
				ConnectionManager.getInstance().sendPacket(account, packet);
				return;
			}
			ConnectionManager.getInstance().sendRequest(account, packet,
					new OnResponseListener() {

						@Override
						public void onReceived(String account, String packetId,
								IQ iq) {
							if (iq instanceof Chat && ((Chat) iq).isValid())
								onChatReceived(account, (Chat) iq);
							else
								onError(account, packetId, iq);
						}

						@Override
						public void onError(String account, String packetId,
								IQ iq) {
							onModifiedAvailable(account);
						}

						@Override
						public void onTimeout(String account, String packetId) {
							onError(account, packetId, null);
						}

						@Override
						public void onDisconnect(String account, String packetId) {
						}

					});
		} catch (NetworkException e) {
		}
	}

	private void sendItemUpdate(String account, String user, SaveMode saveMode,
			OtrMode otrMode) throws NetworkException {
		Item extension = new Item();
		extension.setJid(user);
		extension.setOtr(otrMode);
		extension.setSave(saveMode);
		Pref packet = new Pref();
		packet.addItem(extension);
		packet.setType(Type.SET);
		ConnectionManager.getInstance().sendPacket(account, packet);
	}

	private void sendItemRemove(String account, String user)
			throws NetworkException {
		Item extension = new Item();
		extension.setJid(user);
		ItemRemove packet = new ItemRemove();
		packet.addItem(extension);
		packet.setType(Type.SET);
		ConnectionManager.getInstance().sendPacket(account, packet);
	}

	public void setOtrMode(String account, String user, OtrMode otrMode)
			throws NetworkException {
		ArchivePreference itemArchivePreference = getItemArchivePreference(
				account, user);
		if (itemArchivePreference != null
				&& itemArchivePreference.getOtrMode() == otrMode)
			return;
		ArchivePreference defaultArchivePreference = defaults.get(account);
		SaveMode userSaveMode = getUserSaveMode(account, user);
		if (userSaveMode == null) {
			if (otrMode == OtrMode.require)
				userSaveMode = SaveMode.fls;
			else
				userSaveMode = SaveMode.body;
		}
		if (itemArchivePreference == null) {
			if (defaultArchivePreference != null
					&& defaultArchivePreference.getOtrMode() == otrMode)
				return;
			else
				sendItemUpdate(account, user, userSaveMode, otrMode);
		} else {
			if (defaultArchivePreference != null
					&& defaultArchivePreference.getOtrMode() == otrMode)
				sendItemRemove(account, user);
			else
				sendItemUpdate(account, user, userSaveMode, otrMode);
		}
	}

	/**
	 * @param account
	 * @param user
	 * @return Selected OTR mode or <code>null</code> if there is no either user
	 *         settings either default settings.
	 */
	public OtrMode getOtrMode(String account, String user) {
		ArchivePreference archivePreference = getItemArchivePreference(account,
				user);
		if (archivePreference == null)
			archivePreference = defaults.get(account);
		if (archivePreference == null)
			return null;
		return archivePreference.getOtrMode();
	}

	/**
	 * @param account
	 * @param user
	 * @param session
	 * @return <code>null</code> if there is no session, user and default
	 *         settings.
	 */
	public SaveMode getSaveMode(String account, String user, String session) {
		SaveMode sessionSaveMode = sessionSaves.get(account, session);
		if (sessionSaveMode != null)
			return sessionSaveMode;
		return getUserSaveMode(account, user);
	}

	private ArchivePreference getItemArchivePreference(String account,
			String user) {
		Map<MatchMode, Map<String, ArchivePreference>> map = items.get(account);
		if (map == null)
			return null;
		ArchivePreference result = map.get(MatchMode.exect).get(user);
		if (result != null)
			return result;
		result = map.get(MatchMode.bare).get(Jid.getBareAddress(user));
		if (result != null)
			return result;
		return map.get(MatchMode.domain).get(Jid.getServer(user));
	}

	private void sendSessionUpdate(String account, String session,
			SaveMode saveMode) throws NetworkException {
		Session extension = new Session();
		extension.setThread(session);
		extension.setTimeout(SESSION_TIMEOUT);
		extension.setSave(saveMode);
		Pref packet = new Pref();
		packet.addSession(extension);
		packet.setType(Type.SET);
		ConnectionManager.getInstance().sendPacket(account, packet);
		sessionSaves.put(account, session, saveMode);
	}

	private void sendSessionRemove(String account, String session)
			throws NetworkException {
		Session extension = new Session();
		extension.setThread(session);
		SessionRemove packet = new SessionRemove();
		packet.addSession(extension);
		packet.setType(Type.SET);
		ConnectionManager.getInstance().sendPacket(account, packet);
		sessionSaves.remove(account, session);
	}

	private SaveMode getUserSaveMode(String account, String user) {
		ArchivePreference archivePreference = getItemArchivePreference(account,
				user);
		if (archivePreference != null)
			return archivePreference.getSaveMode();
		Boolean save = saves.get(account);
		if (save != null)
			return save ? SaveMode.body : SaveMode.fls;
		archivePreference = defaults.get(account);
		if (archivePreference != null)
			return archivePreference.getSaveMode();
		return null;
	}

	public void setSaveMode(String account, String user, String session,
			SaveMode saveMode) throws NetworkException {
		if (AccountManager.getInstance().getArchiveMode(account) != ArchiveMode.server)
			return;
		SaveMode sessionSaveMode = sessionSaves.get(account, session);
		if (sessionSaveMode == saveMode)
			return;
		SaveMode userSaveMode = getUserSaveMode(account, user);
		if (sessionSaveMode == null) {
			if (userSaveMode == saveMode)
				return;
			else
				sendSessionUpdate(account, session, saveMode);
		} else {
			if (userSaveMode == saveMode)
				sendSessionRemove(account, session);
			else
				sendSessionUpdate(account, session, saveMode);
		}
	}

	public boolean isModificationsSucceed(String account) {
		ModificationStorage modificationStorage = modificationStorages
				.get(account);
		if (modificationStorage == null)
			return false;
		return modificationStorage.isSucceed();
	}

	@Override
	public void onAccountArchiveModeChanged(AccountItem accountItem) {
		availableArchiveRequestProvider.remove(accountItem.getAccount());
	}

}
